from django.core.management.base import BaseCommand
from django.contrib.auth.models import User
from django.db import transaction
from battles.models import BattleStatistics
from battles.signals import recalculate_user_statistics

"""
# 重置所有用户的对战统计
python manage.py reset_battle_stats

# 重置指定用户的对战统计
python manage.py reset_battle_stats --user username

# 重置指定用户ID的对战统计
python manage.py reset_battle_stats --user-id 123

# 完全清空所有统计数据（不重新计算）
python manage.py reset_battle_stats --clear-only

# 试运行模式（显示将要重置的用户，但不实际执行）
python manage.py reset_battle_stats --dry-run

# 重置多个用户的统计
python manage.py reset_battle_stats --user user1 --user user2 --user user3
"""


class Command(BaseCommand):
    help = '重置用户的对战统计数据，可以重新计算或完全清空'

    def add_arguments(self, parser):
        parser.add_argument(
            '--user',
            action='append',
            help='指定要重置统计的用户名（可以多次使用来指定多个用户）',
        )
        parser.add_argument(
            '--user-id',
            type=int,
            action='append',
            help='指定要重置统计的用户ID（可以多次使用来指定多个用户）',
        )
        parser.add_argument(
            '--clear-only',
            action='store_true',
            help='仅清空统计数据，不重新计算（将所有统计重置为0）',
        )
        parser.add_argument(
            '--dry-run',
            action='store_true',
            help='试运行模式，显示将要重置的用户但不实际执行',
        )
        parser.add_argument(
            '--force',
            action='store_true',
            help='强制执行，不显示确认提示',
        )

    def handle(self, *args, **options):
        # 获取要重置统计的用户列表
        users_to_reset = self._get_users_to_reset(options)
        
        if not users_to_reset:
            self.stdout.write(
                self.style.ERROR('没有找到要重置统计的用户')
            )
            return

        # 显示将要重置的用户信息
        self._display_users_info(users_to_reset, options)

        # 试运行模式，只显示信息不执行
        if options['dry_run']:
            self.stdout.write(
                self.style.WARNING('试运行模式：以上用户的统计数据将被重置，但本次不会实际执行')
            )
            return

        # 确认操作
        if not options['force']:
            if not self._confirm_reset(users_to_reset, options):
                self.stdout.write(
                    self.style.WARNING('操作已取消')
                )
                return

        # 执行重置操作
        self._reset_statistics(users_to_reset, options)

    def _get_users_to_reset(self, options):
        """获取要重置统计的用户列表"""
        users = []

        # 如果指定了用户名
        if options['user']:
            for username in options['user']:
                try:
                    user = User.objects.get(username=username)
                    users.append(user)
                except User.DoesNotExist:
                    self.stdout.write(
                        self.style.ERROR(f'用户 "{username}" 不存在')
                    )

        # 如果指定了用户ID
        if options['user_id']:
            for user_id in options['user_id']:
                try:
                    user = User.objects.get(id=user_id)
                    users.append(user)
                except User.DoesNotExist:
                    self.stdout.write(
                        self.style.ERROR(f'用户ID "{user_id}" 不存在')
                    )

        # 如果没有指定用户，则重置所有有统计记录的用户
        if not users:
            users = User.objects.filter(battle_stats__isnull=False).distinct()

        return users

    def _display_users_info(self, users, options):
        """显示用户信息"""
        self.stdout.write(
            self.style.SUCCESS(f'找到 {len(users)} 个用户需要重置统计：')
        )
        
        for user in users:
            try:
                stats = user.battle_stats
                self.stdout.write(
                    f'  - {user.username} (ID: {user.id}) - '
                    f'总对战: {stats.total_battles}, '
                    f'胜率: {stats.get_win_rate():.1f}%, '
                    f'总得分: {stats.total_score}'
                )
            except BattleStatistics.DoesNotExist:
                self.stdout.write(
                    f'  - {user.username} (ID: {user.id}) - 无统计记录'
                )

        if options['clear_only']:
            self.stdout.write(
                self.style.WARNING('\n操作模式：仅清空统计数据（不重新计算）')
            )
        else:
            self.stdout.write(
                self.style.SUCCESS('\n操作模式：重新计算统计数据')
            )

    def _confirm_reset(self, users, options):
        """确认重置操作"""
        action = "清空" if options['clear_only'] else "重新计算"
        
        self.stdout.write(
            self.style.WARNING(f'\n警告：即将{action} {len(users)} 个用户的对战统计数据！')
        )
        
        response = input('确认继续吗？(y/N): ')
        return response.lower() in ['y', 'yes']

    def _reset_statistics(self, users, options):
        """执行重置统计操作"""
        success_count = 0
        error_count = 0

        self.stdout.write(
            self.style.SUCCESS('\n开始重置统计数据...')
        )

        for user in users:
            try:
                with transaction.atomic():
                    if options['clear_only']:
                        # 仅清空统计数据
                        self._clear_user_statistics(user)
                        self.stdout.write(f'✓ 已清空用户 {user.username} 的统计数据')
                    else:
                        # 重新计算统计数据
                        recalculate_user_statistics(user)
                        self.stdout.write(f'✓ 已重新计算用户 {user.username} 的统计数据')
                    
                    success_count += 1

            except Exception as e:
                self.stdout.write(
                    self.style.ERROR(f'✗ 重置用户 {user.username} 统计时出错: {str(e)}')
                )
                error_count += 1

        # 显示结果摘要
        self.stdout.write(
            self.style.SUCCESS(f'\n重置完成！成功: {success_count}, 失败: {error_count}')
        )

        if error_count > 0:
            self.stdout.write(
                self.style.WARNING('部分用户重置失败，请检查错误信息')
            )

    def _clear_user_statistics(self, user):
        """清空用户统计数据"""
        stats, created = BattleStatistics.objects.get_or_create(
            user=user,
            defaults={
                'total_battles': 0,
                'wins': 0,
                'losses': 0,
                'draws': 0,
                'total_score': 0,
                'average_score': 0.0,
                'best_score': 0,
                'total_kills': 0,
                'total_deaths': 0,
                'total_damage_dealt': 0,
                'total_damage_received': 0,
                'total_healing': 0,
                'total_command_fail_count': 0,
                'total_rmb': 0,
                'average_base_health': 0.0,
                'current_rank': 0,
                'highest_rank': 0,
                'rating': 0,
                'last_battle_at': None,
            }
        )

        if not created:
            # 重置所有统计字段为0
            stats.total_battles = 0
            stats.wins = 0
            stats.losses = 0
            stats.draws = 0
            stats.total_score = 0
            stats.average_score = 0.0
            stats.best_score = 0
            stats.total_kills = 0
            stats.total_deaths = 0
            stats.total_damage_dealt = 0
            stats.total_damage_received = 0
            stats.total_healing = 0
            stats.total_command_fail_count = 0
            stats.total_rmb = 0
            stats.average_base_health = 0.0
            stats.current_rank = 0
            stats.highest_rank = 0
            stats.rating = 0
            stats.last_battle_at = None
            stats.save()